#pragma once
template<class iterator>
struct ReverseIterator
{
	typedef typename iterator::Ref Ref;
	typedef typename iterator::Ptr Ptr;
	typedef ReverseIterator<iterator> Self;
	ReverseIterator(iterator it)
		:lt(it)
	{
	}
	Ref operator*()
	{
		iterator tmp(lt);
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	Self& operator++()
	{
		lt--;
		return *this;
	}
	Self& operator--()
	{
		lt++;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		lt--;
		return tmp;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		lt++;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return lt != l.lt;
	}
	bool operator==(const Self& l)
	{
		return lt == l.lt;
	}
	iterator lt;
};

template<class T>
struct ReverseIterator<T*>
{
	typedef T& Ref;
	typedef T* Ptr;
	typedef ReverseIterator<T*> Self;
	ReverseIterator(T* it)
		:lt(it)
	{
	}
	Ref operator*()
	{
		T* tmp(lt);
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	Self& operator++()
	{
		lt--;
		return *this;
	}
	Self& operator--()
	{
		lt++;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		lt--;
		return tmp;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		lt++;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return lt != l.lt;
	}
	bool operator==(const Self& l)
	{
		return lt == l.lt;
	}
	T* lt;
};

template<class T>
struct ReverseIterator<const T*>
{
	typedef const T& Ref;
	typedef const T* Ptr;
	typedef ReverseIterator<const T*> Self;
	ReverseIterator(const T* it)
		:lt(it)
	{
	}
	Ref operator*()
	{
		const T* tmp(lt);
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	Self& operator++()
	{
		lt--;
		return *this;
	}
	Self& operator--()
	{
		lt++;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		lt--;
		return tmp;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		lt++;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return lt != l.lt;
	}
	bool operator==(const Self& l)
	{
		return lt == l.lt;
	}
	const T* lt;
};